home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / sun / instrument / InstrumentationImpl.class (.txt) next >
Encoding:
Java Class File  |  2006-11-29  |  6.2 KB  |  248 lines
  1. package sun.instrument;
  2.  
  3. import java.lang.instrument.ClassDefinition;
  4. import java.lang.instrument.ClassFileTransformer;
  5. import java.lang.instrument.Instrumentation;
  6. import java.lang.reflect.AccessibleObject;
  7. import java.lang.reflect.Method;
  8. import java.security.AccessController;
  9. import java.security.ProtectionDomain;
  10. import java.util.jar.JarFile;
  11.  
  12. public class InstrumentationImpl implements Instrumentation {
  13.    private final TransformerManager mTransformerManager = new TransformerManager(false);
  14.    private TransformerManager mRetransfomableTransformerManager = null;
  15.    private final long mNativeAgent;
  16.    private final boolean mEnvironmentSupportsRedefineClasses;
  17.    private volatile boolean mEnvironmentSupportsRetransformClassesKnown;
  18.    private volatile boolean mEnvironmentSupportsRetransformClasses;
  19.    private final boolean mEnvironmentSupportsNativeMethodPrefix;
  20.  
  21.    private InstrumentationImpl(long var1, boolean var3, boolean var4) {
  22.       this.mNativeAgent = var1;
  23.       this.mEnvironmentSupportsRedefineClasses = var3;
  24.       this.mEnvironmentSupportsRetransformClassesKnown = false;
  25.       this.mEnvironmentSupportsRetransformClasses = false;
  26.       this.mEnvironmentSupportsNativeMethodPrefix = var4;
  27.    }
  28.  
  29.    public void addTransformer(ClassFileTransformer var1) {
  30.       this.addTransformer(var1, false);
  31.    }
  32.  
  33.    public synchronized void addTransformer(ClassFileTransformer var1, boolean var2) {
  34.       if (var1 == null) {
  35.          throw new NullPointerException("null passed as 'transformer' in addTransformer");
  36.       } else {
  37.          if (var2) {
  38.             if (!this.isRetransformClassesSupported()) {
  39.                throw new UnsupportedOperationException("adding retransformable transformers is not supported in this environment");
  40.             }
  41.  
  42.             if (this.mRetransfomableTransformerManager == null) {
  43.                this.mRetransfomableTransformerManager = new TransformerManager(true);
  44.             }
  45.  
  46.             this.mRetransfomableTransformerManager.addTransformer(var1);
  47.             if (this.mRetransfomableTransformerManager.getTransformerCount() == 1) {
  48.                this.setHasRetransformableTransformers(this.mNativeAgent, true);
  49.             }
  50.          } else {
  51.             this.mTransformerManager.addTransformer(var1);
  52.          }
  53.  
  54.       }
  55.    }
  56.  
  57.    public synchronized boolean removeTransformer(ClassFileTransformer var1) {
  58.       if (var1 == null) {
  59.          throw new NullPointerException("null passed as 'transformer' in removeTransformer");
  60.       } else {
  61.          TransformerManager var2 = this.findTransformerManager(var1);
  62.          if (var2 != null) {
  63.             var2.removeTransformer(var1);
  64.             if (var2.isRetransformable() && var2.getTransformerCount() == 0) {
  65.                this.setHasRetransformableTransformers(this.mNativeAgent, false);
  66.             }
  67.  
  68.             return true;
  69.          } else {
  70.             return false;
  71.          }
  72.       }
  73.    }
  74.  
  75.    public boolean isModifiableClass(Class<?> var1) {
  76.       if (var1 == null) {
  77.          throw new NullPointerException("null passed as 'theClass' in isModifiableClass");
  78.       } else {
  79.          return this.isModifiableClass0(this.mNativeAgent, var1);
  80.       }
  81.    }
  82.  
  83.    public boolean isRetransformClassesSupported() {
  84.       if (!this.mEnvironmentSupportsRetransformClassesKnown) {
  85.          this.mEnvironmentSupportsRetransformClasses = this.isRetransformClassesSupported0(this.mNativeAgent);
  86.          this.mEnvironmentSupportsRetransformClassesKnown = true;
  87.       }
  88.  
  89.       return this.mEnvironmentSupportsRetransformClasses;
  90.    }
  91.  
  92.    public void retransformClasses(Class<?>[] var1) {
  93.       if (!this.isRetransformClassesSupported()) {
  94.          throw new UnsupportedOperationException("retransformClasses is not supported in this environment");
  95.       } else {
  96.          this.retransformClasses0(this.mNativeAgent, var1);
  97.       }
  98.    }
  99.  
  100.    public boolean isRedefineClassesSupported() {
  101.       return this.mEnvironmentSupportsRedefineClasses;
  102.    }
  103.  
  104.    public void redefineClasses(ClassDefinition[] var1) throws ClassNotFoundException {
  105.       if (!this.isRedefineClassesSupported()) {
  106.          throw new UnsupportedOperationException("redefineClasses is not supported in this environment");
  107.       } else if (var1 == null) {
  108.          throw new NullPointerException("null passed as 'definitions' in redefineClasses");
  109.       } else {
  110.          for(int var2 = 0; var2 < var1.length; ++var2) {
  111.             if (var1[var2] == null) {
  112.                throw new NullPointerException("element of 'definitions' is null in redefineClasses");
  113.             }
  114.          }
  115.  
  116.          if (var1.length != 0) {
  117.             this.redefineClasses0(this.mNativeAgent, var1);
  118.          }
  119.       }
  120.    }
  121.  
  122.    public Class[] getAllLoadedClasses() {
  123.       return this.getAllLoadedClasses0(this.mNativeAgent);
  124.    }
  125.  
  126.    public Class[] getInitiatedClasses(ClassLoader var1) {
  127.       return this.getInitiatedClasses0(this.mNativeAgent, var1);
  128.    }
  129.  
  130.    public long getObjectSize(Object var1) {
  131.       if (var1 == null) {
  132.          throw new NullPointerException("null passed as 'objectToSize' in getObjectSize");
  133.       } else {
  134.          return this.getObjectSize0(this.mNativeAgent, var1);
  135.       }
  136.    }
  137.  
  138.    public void appendToBootstrapClassLoaderSearch(JarFile var1) {
  139.       this.appendToClassLoaderSearch0(this.mNativeAgent, var1.getName(), true);
  140.    }
  141.  
  142.    public void appendToSystemClassLoaderSearch(JarFile var1) {
  143.       this.appendToClassLoaderSearch0(this.mNativeAgent, var1.getName(), false);
  144.    }
  145.  
  146.    public boolean isNativeMethodPrefixSupported() {
  147.       return this.mEnvironmentSupportsNativeMethodPrefix;
  148.    }
  149.  
  150.    public synchronized void setNativeMethodPrefix(ClassFileTransformer var1, String var2) {
  151.       if (!this.isNativeMethodPrefixSupported()) {
  152.          throw new UnsupportedOperationException("setNativeMethodPrefix is not supported in this environment");
  153.       } else if (var1 == null) {
  154.          throw new NullPointerException("null passed as 'transformer' in setNativeMethodPrefix");
  155.       } else {
  156.          TransformerManager var3 = this.findTransformerManager(var1);
  157.          if (var3 == null) {
  158.             throw new IllegalArgumentException("transformer not registered in setNativeMethodPrefix");
  159.          } else {
  160.             var3.setNativeMethodPrefix(var1, var2);
  161.             String[] var4 = var3.getNativeMethodPrefixes();
  162.             this.setNativeMethodPrefixes(this.mNativeAgent, var4, var3.isRetransformable());
  163.          }
  164.       }
  165.    }
  166.  
  167.    private TransformerManager findTransformerManager(ClassFileTransformer var1) {
  168.       if (this.mTransformerManager.includesTransformer(var1)) {
  169.          return this.mTransformerManager;
  170.       } else {
  171.          return this.mRetransfomableTransformerManager != null && this.mRetransfomableTransformerManager.includesTransformer(var1) ? this.mRetransfomableTransformerManager : null;
  172.       }
  173.    }
  174.  
  175.    private native boolean isModifiableClass0(long var1, Class<?> var3);
  176.  
  177.    private native boolean isRetransformClassesSupported0(long var1);
  178.  
  179.    private native void setHasRetransformableTransformers(long var1, boolean var3);
  180.  
  181.    private native void retransformClasses0(long var1, Class<?>[] var3);
  182.  
  183.    private native void redefineClasses0(long var1, ClassDefinition[] var3) throws ClassNotFoundException;
  184.  
  185.    private native Class[] getAllLoadedClasses0(long var1);
  186.  
  187.    private native Class[] getInitiatedClasses0(long var1, ClassLoader var3);
  188.  
  189.    private native long getObjectSize0(long var1, Object var3);
  190.  
  191.    private native void appendToClassLoaderSearch0(long var1, String var3, boolean var4);
  192.  
  193.    private native void setNativeMethodPrefixes(long var1, String[] var3, boolean var4);
  194.  
  195.    private static void setAccessible(AccessibleObject var0, boolean var1) {
  196.       AccessController.doPrivileged(new 1(var0, var1));
  197.    }
  198.  
  199.    private void loadClassAndStartAgent(String var1, String var2, String var3) throws Throwable {
  200.       ClassLoader var4 = ClassLoader.getSystemClassLoader();
  201.       Class var5 = var4.loadClass(var1);
  202.       Method var6 = null;
  203.       NoSuchMethodException var7 = null;
  204.       boolean var8 = false;
  205.  
  206.       try {
  207.          var6 = var5.getMethod(var2, String.class, Instrumentation.class);
  208.          var8 = true;
  209.       } catch (NoSuchMethodException var11) {
  210.          var7 = var11;
  211.       }
  212.  
  213.       if (var6 == null) {
  214.          try {
  215.             var6 = var5.getMethod(var2, String.class);
  216.          } catch (NoSuchMethodException var10) {
  217.             throw var7;
  218.          }
  219.       }
  220.  
  221.       setAccessible(var6, true);
  222.       if (var8) {
  223.          var6.invoke((Object)null, var3, this);
  224.       } else {
  225.          var6.invoke((Object)null, var3);
  226.       }
  227.  
  228.       setAccessible(var6, false);
  229.    }
  230.  
  231.    private void loadClassAndCallPremain(String var1, String var2) throws Throwable {
  232.       this.loadClassAndStartAgent(var1, "premain", var2);
  233.    }
  234.  
  235.    private void loadClassAndCallAgentmain(String var1, String var2) throws Throwable {
  236.       this.loadClassAndStartAgent(var1, "agentmain", var2);
  237.    }
  238.  
  239.    private byte[] transform(ClassLoader var1, String var2, Class var3, ProtectionDomain var4, byte[] var5, boolean var6) {
  240.       TransformerManager var7 = var6 ? this.mRetransfomableTransformerManager : this.mTransformerManager;
  241.       return var7 == null ? null : var7.transform(var1, var2, var3, var4, var5);
  242.    }
  243.  
  244.    static {
  245.       System.loadLibrary("instrument");
  246.    }
  247. }
  248.